{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Faster Inference on Raspberry Pi with Amazon SageMaker Neo\n",
    "\n",
    "\n",
    "Amazon SageMaker Neo enables developers to train machine learning models once and run them anywhere in the cloud and at the edge. Amazon SageMaker Neo optimizes models to run up to twice as fast, with less than a tenth of the memory footprint, with no loss in accuracy.\n",
    "\n",
    "This notebook demonstrates how a MobileNet based object detection model created in TensorFlow Lite can be compiled using Amazon SageMaker Neo for use on a Raspberry Pi 3B, a common edge platform for experimentation and development, and allows us to see the performance benefits of Sagemaker Neo on our own hardware."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "The general flow of this tutorial is as follows:\n",
    "1. Set up our device to access Amazon Web Services\n",
    "1. Prepare our model for compilation with SageMaker Neo\n",
    "1. Compile with SageMaker Neo\n",
    "1. Compare the performance of the model compiled with SageMaker Neo against that of the original model executing with TensorFlow Lite\n",
    "\n",
    "> This notebook is intended to be run on a Raspberry Pi 3B, but everything except the inference section can be run on a PC. As such, if running on a PC, it will not be possible to directly observe the performance benefits of Neo. Running on Raspberry Pi will allow for the full notebook to execute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prerequisites\n",
    "\n",
    "This tutorial leverages Amazon Web Services (AWS) capabilities and assumes we have a Raspberry Pi to use for inference. As such, the below are required:\n",
    "\n",
    "#### Required\n",
    "* An AWS account\n",
    "    * AWS provides [instructions for creating an account](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) if you do not already have one.\n",
    "* A Raspberry Pi 3B running Raspberry Pi OS 10 to run the benchmarks on a personal device (support for Raspberry Pi 4B running Raspberry Pi OS 10 not tested)\n",
    "\n",
    "#### Recommended\n",
    "* A fresh [Python virtual environment](https://docs.python.org/3/tutorial/venv.html) to avoid conflicts when installing Python packages \n",
    "\n",
    "\n",
    "## Get Started with Amazon Web Services and Boto3\n",
    "\n",
    "Amazon SageMaker Neo is a service provided by Amazon Web Services, and using it requires that we do some basic configuration to set up our account on our device, set up access to our resources, and specify which [AWS Region](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/) we want to execute in. While it is possible to access SageMaker Neo [via a web GUI](https://console.aws.amazon.com/sagemaker/home), this tutorial will leverage Boto3 to programmatically interact with SageMaker Neo and other AWS services.\n",
    "\n",
    "### Install Packages\n",
    "\n",
    "Before we can get started, we need to make sure that we have all of the necessary Python libraries installed on our machine. Specifically, we will be relying on [Boto3](https://github.com/boto/boto3) to access AWS services. If Boto3 is not already installed, it can be installed by running the below cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple\n",
      "Requirement already satisfied: boto3 in /home/pi/.local/lib/python3.7/site-packages (1.12.6)\n",
      "Requirement already satisfied: jmespath<1.0.0,>=0.7.1 in /home/pi/.local/lib/python3.7/site-packages (from boto3) (0.9.5)\n",
      "Requirement already satisfied: s3transfer<0.4.0,>=0.3.0 in /home/pi/.local/lib/python3.7/site-packages (from boto3) (0.3.3)\n",
      "Requirement already satisfied: botocore<1.16.0,>=1.15.6 in /home/pi/.local/lib/python3.7/site-packages (from boto3) (1.15.6)\n",
      "Requirement already satisfied: python-dateutil<3.0.0,>=2.1 in /home/pi/.local/lib/python3.7/site-packages (from botocore<1.16.0,>=1.15.6->boto3) (2.8.1)\n",
      "Requirement already satisfied: urllib3<1.26,>=1.20; python_version != \"3.4\" in /usr/lib/python3/dist-packages (from botocore<1.16.0,>=1.15.6->boto3) (1.24.1)\n",
      "Requirement already satisfied: docutils<0.16,>=0.10 in /usr/lib/python3/dist-packages (from botocore<1.16.0,>=1.15.6->boto3) (0.14)\n",
      "Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil<3.0.0,>=2.1->botocore<1.16.0,>=1.15.6->boto3) (1.12.0)\n"
     ]
    }
   ],
   "source": [
    "!pip3 install boto3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Up Credentials\n",
    "Running Boto3 requires Amazon Web Services credentials be set up on our device. [The Boto3 documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html#configuration) has instructions for how to do this, but it is also easy to configure the credentials ourselves. By default, credentials should be stored in the file `~/.aws/credentials` and look as follows:\n",
    "\n",
    "```\n",
    "[default]\n",
    "aws_access_key_id = YOUR_ACCESS_KEY\n",
    "aws_secret_access_key = YOUR_SECRET_KEY\n",
    "```\n",
    "\n",
    "The [AWS documentation](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys) has instructions for how to get the necessary `aws_access_key_id` and `aws_secret_access_key`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Up Clients for Interaction with Amazon Web Servies\n",
    "\n",
    "The first step to get started with Boto3 is to import it and set up clients to interact with AWS services. We will be leveraging two AWS services in this tutorial:\n",
    "1. Amazon SageMaker Neo, for deep learning model compilation\n",
    "2. Amazon S3, for storage of our model before and after compilation\n",
    "\n",
    "We can set up clients for interaction with these services as follows:\n",
    "\n",
    "> Note: data stored in S3 is accessible only from within a single AWS region. As such, the sagemaker client and s3 client must be configured to use the same AWS region."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import boto3\n",
    "\n",
    "AWS_REGION = 'us-west-2'\n",
    "sagemaker_client = boto3.client('sagemaker', region_name=AWS_REGION)\n",
    "s3_client = boto3.client('s3', region_name=AWS_REGION)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up IAM Role\n",
    "\n",
    "In order to use SageMaker Neo we will need to set up an [IAM role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html). This role will allow SageMaker to run under our account and will also give it access to the S3 bucket where we upload our pretrained model.\n",
    "\n",
    "The process to programatically set up an IAM role is a bit complicated (it can be done more easily using the web GUI), but it looks as follows.\n",
    "\n",
    "First, set up the IAM client and name the role:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "iam_client = boto3.client('iam', region_name=AWS_REGION)\n",
    "role_name = 'new-pi-demo-test-role'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, create a dictionary describing the IAM policy to be applied. This policy is used to create a new IAM role."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "policy = {\n",
    "    'Statement': [\n",
    "        {\n",
    "            'Action': 'sts:AssumeRole',\n",
    "            'Effect': 'Allow',\n",
    "            'Principal': {'Service': 'sagemaker.amazonaws.com'},\n",
    "        }],  \n",
    "     'Version': '2012-10-17'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now look to see if a role of name `role_name` already exists. If it does, we note its [ARN](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns), the name by which the role is referred to in AWS systems. If the role does not already exist, we create the role and record the new ARN.\n",
    "\n",
    "> If you see an error stating `An error occurred (EntityAlreadyExists) when calling the CreateRole operation: Role with name new-pi-demo-test-role already exists`, you may be able to resolve it by using credentials from a different AWS account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "roles = iam_client.list_roles()\n",
    "role_arn = None\n",
    "for role in roles['Roles']:\n",
    "    if role['RoleName'] == role_name:\n",
    "        role_arn = role['Arn']\n",
    "        \n",
    "if role_arn == None:\n",
    "    new_role = iam_client.create_role(\n",
    "        AssumeRolePolicyDocument=json.dumps(policy),\n",
    "        Path='/',\n",
    "        RoleName=role_name,\n",
    "    )\n",
    "    role_arn = new_role['Role']['Arn']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With our role created, we now need to give it the necessary permissions to run SageMaker Neo and access data we store in S3. To give our role those permissions, we make the below function calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "iam_client.attach_role_policy(\n",
    "    RoleName=role_name,\n",
    "    PolicyArn='arn:aws:iam::aws:policy/AmazonSageMakerFullAccess'\n",
    ")\n",
    "\n",
    "iam_client.attach_role_policy(\n",
    "    RoleName=role_name,\n",
    "    PolicyArn='arn:aws:iam::aws:policy/AmazonS3FullAccess'\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare Model for Compilation\n",
    "\n",
    "Before we can compile our pretrained model for on device inference using SageMaker Neo, we need to put it in a location accessible to SageMaker Neo. As SageMaker Neo only accepts inputs from Amazon S3, this means that we will need to upload our pretrained model to S3.\n",
    "\n",
    "### Get Local Copy of Model\n",
    "First, we need to get a local copy of our pretrained model. As ours is hosted on the web, we can get a copy using curl."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "100 2741k  100 2741k    0     0  6496k      0 --:--:-- --:--:-- --:--:-- 6496k\n"
     ]
    }
   ],
   "source": [
    "model_zip_filename = './coco_ssd_mobilenet_v1_1.0.zip'\n",
    "!curl http://storage.googleapis.com/download.tensorflow.org/models/tflite/coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip \\\n",
    "    --output {model_zip_filename}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As our model was stored in a zip file, we need to unzip it to get model out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Archive:  ./coco_ssd_mobilenet_v1_1.0.zip\r\n",
      "  inflating: detect.tflite           \r\n",
      "  inflating: labelmap.txt            \r\n"
     ]
    }
   ],
   "source": [
    "!unzip -u {model_zip_filename}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that `detect.tflite` was extracted from the zip file, perfect! This is the file we want to pass into SageMaker Neo for compilation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_filename = 'detect.tflite'\n",
    "model_name = model_filename.split('.')[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Upload Model to S3\n",
    "\n",
    "Before we can upload our model to S3, we need to create a [\"bucket\"](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html) to store it in. We can do this using boto3 as follows:\n",
    "\n",
    "First, we need to give our bucket a unique name:\n",
    "\n",
    "> **NOTE**: This bucket *must* be renamed as S3 bucket names must be globally unique across all AWS accounts. As the default bucket name below has been used before, bucket creation will fail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: manually rename this bucket\n",
    "bucket_name = 'dvisnty-bucket-party'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to create a bucket of this name using Boto3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bucket dvisnty-bucket-party already exists. No action needed.\n"
     ]
    }
   ],
   "source": [
    "if boto3.resource('s3').Bucket(bucket_name) not in boto3.resource('s3').buckets.all():\n",
    "    s3_client.create_bucket(\n",
    "        Bucket=bucket_name,\n",
    "        CreateBucketConfiguration={\n",
    "            'LocationConstraint': AWS_REGION\n",
    "        }\n",
    "    )\n",
    "else:\n",
    "    print(f'Bucket {bucket_name} already exists. No action needed.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've created our bucket, we just need to upload our model, `detect.tflite`, to S3. SageMaker Neo expects the model be uploaded as a `.tar.gz` file, so we need to first compress our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_tar = model_name + '.tar.gz'\n",
    "!tar -czf {model_tar} {model_filename}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it is time to upload our pretrained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3_client.upload_file(model_tar, bucket_name, model_tar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model should now be accessible at"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s3://dvisnty-bucket-party/detect.tar.gz'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3_input_location = f's3://{bucket_name}/{model_tar}'\n",
    "s3_input_location"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compile with SageMaker Neo\n",
    "\n",
    "Now that we have our model uploaded to S3, we just need to invoke SageMaker Neo on our input.\n",
    "\n",
    "SageMaker Neo requires the following information in order to run:\n",
    "1. The location of the input model (in S3)\n",
    "2. Where to save the compiled model (in S3)\n",
    "3. The framework of the input model (TensorFlow Lite, MXNet, etc.)\n",
    "4. The shapes of the model's inputs\n",
    "5. The name of the target device to compile for, or the general details of the hardware platform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set S3 Output Location\n",
    "The finished model will be output to an S3 bucket of our choosing. Here we choose to output to the same bucket as the input model resides in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "s3_output_location = f's3://{bucket_name}/output'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Input Tensor Shapes\n",
    "\n",
    "SageMaker Neo requires the name and shape of every input tensor. These are passed in as `key: value` pairs where `value` is a list of the integer dimensions of an input tensor and `key` is the exact name of an input tensor in the model. \n",
    "\n",
    "> [Netron](https://lutzroeder.github.io/netron/) can be used to visualize a model and find the names/dimensions of the input tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: if the model being compiled is different than the default\n",
    "# for this tutorial, the key in this dictionary will need to be changed\n",
    "# to the new input tensor's name\n",
    "data_shape = '{\"normalized_input_image_tensor\":[1, 300, 300, 3]}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Framework\n",
    "We are using a TensorFlow Lite model for this tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "framework = 'tflite'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Target Device\n",
    "\n",
    "This tutorial targets the Raspberry Pi 3B running Raspberry Pi OS 10. SageMaker comes with a saved configuration for this device that takes into account the capabilities and limitations of the Raspberry Pi 3B, so we use this configuration for ease of use. It is possible to target additional devices, such as the Raspberry Pi 4B, but that requires manually specifying the operating system, instruction set, and capabilities of the processor, e.g. ARM NEON."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "target_device = 'rasp3b'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Submit Model to SageMaker Neo\n",
    "\n",
    "With all of the inputs ready for SageMaker Neo, we now make a call to SageMaker Neo using our previously created Boto3 client."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compilation job for pi-demo1602700548 started\n",
      "Compiling ...\n",
      "Compiling ...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "compilation_job_name = 'pi-demo'+ str(time.time()).split('.')[0]\n",
    "print(f'Compilation job for {compilation_job_name} started')\n",
    "\n",
    "response = sagemaker_client.create_compilation_job(\n",
    "    CompilationJobName=compilation_job_name,\n",
    "    RoleArn=role_arn,\n",
    "    InputConfig={\n",
    "        'S3Uri': s3_input_location,\n",
    "        'DataInputConfig': data_shape,\n",
    "        'Framework': framework.upper()\n",
    "    },\n",
    "    OutputConfig={\n",
    "        'S3OutputLocation': s3_output_location,\n",
    "        'TargetDevice': target_device \n",
    "    },\n",
    "    StoppingCondition={\n",
    "        'MaxRuntimeInSeconds': 900\n",
    "    }\n",
    ")\n",
    "\n",
    "# Uncomment this for additional debug information\n",
    "# print(response)\n",
    "\n",
    "# Poll every 30 sec to check completion status\n",
    "while True:\n",
    "    response = sagemaker_client.describe_compilation_job(CompilationJobName=compilation_job_name)\n",
    "    if response['CompilationJobStatus'] == 'COMPLETED':\n",
    "        break\n",
    "    elif response['CompilationJobStatus'] == 'FAILED':\n",
    "        raise RuntimeError('Compilation failed')\n",
    "    print('Compiling ...')\n",
    "    time.sleep(30)\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Success! At this point compilation is done, and our compiled model specifically targeting the Raspberry Pi 3B is accessible in S3. Let's download our compiled model, consisting of multiple files in a `.tar.gz` file, back to our local machine\n",
    "\n",
    "> If you instead see a failure with the failure reason in the SageMaker console `ClientError: Failed to assume role: An error occurred (AccessDenied) when calling the AssumeRole operation...`, try compiling using a different AWS account's credentials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "object_path = f'output/{model_name}-{target_device}.tar.gz'\n",
    "neo_compiled_model = f'compiled-{model_name}.tar.gz'\n",
    "s3_client.download_file(bucket_name, object_path, neo_compiled_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measure On-device Inference Latency\n",
    "\n",
    "Now that we have our Neo-compiled model, we can run it on a Raspberry Pi. As our model was compiled targeting Raspberry Pi 3B, these instructions will **only** work on a Raspberry Pi 3B running Raspberry Pi OS 10. There will be errors if we try to do inference using this model using either x86_64 Linux or a Raspberry Pi 4B running 64-bit Ubuntu server.\n",
    "\n",
    "From here on out, this tutorial is written with the assumption that we are executing on a Raspberry Pi.\n",
    "\n",
    "> The below steps will not run properly on any platform but a Raspberry Pi 3B running Raspberry Pi OS 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Up the Raspberry Pi\n",
    "\n",
    "We need a few more libraries installed on the Raspberry Pi in order to run inference. Specifically we will want [Neo-AI-DLR](https://github.com/neo-ai/neo-ai-dlr) to run our Neo-compiled model, NumPy for data manipulation and statistics, and PIL to load images. We also want a copy of TensorFlow so we can gauge the impact of compilation using SageMaker Neo versus a baseline. Lastly, we want Matplotlib to generate charts so we can compare performance.\n",
    "\n",
    "> Rather than install the full TensorFlow, it is also possible to install just the TensorFlow Lite runtime. This can be done by following the instructions in the [official TensorFlow Lite documentation](https://www.tensorflow.org/lite/guide/python)\n",
    "\n",
    "> TensorFlow does not provide a current (v2.x) package for Raspberry Pi OS 10 (see https://github.com/tensorflow/tensorflow/issues/29704 for discussion). As such, this tutorial may install an older version of TensorFlow. We can load a more current version of TensorFlow onto a Raspberry Pi, but this requires more work and is out of scope for this tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple\n",
      "Requirement already satisfied: dlr in /usr/local/lib/python3.7/dist-packages/dlr-1.3.0-py3.7.egg (1.3.0)\n",
      "Requirement already satisfied: numpy in /home/pi/.local/lib/python3.7/site-packages (1.19.0)\n",
      "Requirement already satisfied: pillow in /usr/lib/python3/dist-packages (5.4.1)\n",
      "Requirement already satisfied: tensorflow in /home/pi/.local/lib/python3.7/site-packages (1.14.0)\n",
      "Requirement already satisfied: matplotlib in /home/pi/.local/lib/python3.7/site-packages (3.3.2)\n",
      "Requirement already satisfied: termcolor>=1.1.0 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (1.1.0)\n",
      "Requirement already satisfied: six>=1.10.0 in /usr/lib/python3/dist-packages (from tensorflow) (1.12.0)\n",
      "Requirement already satisfied: astor>=0.6.0 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (0.8.1)\n",
      "Requirement already satisfied: tensorflow-estimator<1.15.0rc0,>=1.14.0rc0 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (1.14.0)\n",
      "Requirement already satisfied: wrapt>=1.11.1 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (1.12.0)\n",
      "Requirement already satisfied: tensorboard<2.1.0,>=2.0.0 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (2.0.2)\n",
      "Requirement already satisfied: keras-preprocessing>=1.0.5 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (1.1.0)\n",
      "Requirement already satisfied: protobuf>=3.6.1 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (3.11.3)\n",
      "Requirement already satisfied: grpcio>=1.8.6 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (1.27.2)\n",
      "Requirement already satisfied: wheel>=0.26; python_version >= \"3\" in /usr/lib/python3/dist-packages (from tensorflow) (0.32.3)\n",
      "Requirement already satisfied: google-pasta>=0.1.6 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (0.1.8)\n",
      "Requirement already satisfied: keras-applications>=1.0.8 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (1.0.8)\n",
      "Requirement already satisfied: absl-py>=0.7.0 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (0.9.0)\n",
      "Requirement already satisfied: gast==0.2.2 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (0.2.2)\n",
      "Requirement already satisfied: opt-einsum>=2.3.2 in /home/pi/.local/lib/python3.7/site-packages (from tensorflow) (3.1.0)\n",
      "Requirement already satisfied: certifi>=2020.06.20 in /home/pi/.local/lib/python3.7/site-packages (from matplotlib) (2020.6.20)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /home/pi/.local/lib/python3.7/site-packages (from matplotlib) (1.2.0)\n",
      "Requirement already satisfied: cycler>=0.10 in /home/pi/.local/lib/python3.7/site-packages (from matplotlib) (0.10.0)\n",
      "Requirement already satisfied: python-dateutil>=2.1 in /home/pi/.local/lib/python3.7/site-packages (from matplotlib) (2.8.1)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 in /home/pi/.local/lib/python3.7/site-packages (from matplotlib) (2.4.7)\n",
      "Requirement already satisfied: google-auth<2,>=1.6.3 in /home/pi/.local/lib/python3.7/site-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (1.11.2)\n",
      "Requirement already satisfied: werkzeug>=0.11.15 in /usr/lib/python3/dist-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (0.14.1)\n",
      "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /home/pi/.local/lib/python3.7/site-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (0.4.1)\n",
      "Requirement already satisfied: markdown>=2.6.8 in /home/pi/.local/lib/python3.7/site-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (3.2.1)\n",
      "Requirement already satisfied: setuptools>=41.0.0 in /home/pi/.local/lib/python3.7/site-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (45.2.0)\n",
      "Requirement already satisfied: requests<3,>=2.21.0 in /usr/lib/python3/dist-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (2.21.0)\n",
      "Requirement already satisfied: h5py in /home/pi/.local/lib/python3.7/site-packages (from keras-applications>=1.0.8->tensorflow) (2.10.0)\n",
      "Requirement already satisfied: pyasn1-modules>=0.2.1 in /home/pi/.local/lib/python3.7/site-packages (from google-auth<2,>=1.6.3->tensorboard<2.1.0,>=2.0.0->tensorflow) (0.2.8)\n",
      "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /home/pi/.local/lib/python3.7/site-packages (from google-auth<2,>=1.6.3->tensorboard<2.1.0,>=2.0.0->tensorflow) (4.0.0)\n",
      "Requirement already satisfied: rsa<4.1,>=3.1.4 in /home/pi/.local/lib/python3.7/site-packages (from google-auth<2,>=1.6.3->tensorboard<2.1.0,>=2.0.0->tensorflow) (4.0)\n",
      "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/lib/python3/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard<2.1.0,>=2.0.0->tensorflow) (1.0.0)\n",
      "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /home/pi/.local/lib/python3.7/site-packages (from pyasn1-modules>=0.2.1->google-auth<2,>=1.6.3->tensorboard<2.1.0,>=2.0.0->tensorflow) (0.4.8)\n"
     ]
    }
   ],
   "source": [
    "!pip3 install numpy pillow tensorflow matplotlib https://neo-ai-dlr-release.s3-us-west-2.amazonaws.com/v1.3.0/pi-armv7l-raspbian4.14.71-glibc2_24-libstdcpp3_4/dlr-1.3.0-py3-none-any.whl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to perform inference, we will need to have an image to pass into our object detection model. As our model was trained on the [COCO dataset](https://cocodataset.org/#home), we pass an arbitrary image from the dataset into our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "100 48109    0 48109    0     0   319k      0 --:--:-- --:--:-- --:--:--  321k\n"
     ]
    }
   ],
   "source": [
    "input_image_filename = './input_image.jpg'\n",
    "!curl https://farm9.staticflickr.com/8325/8077197378_79efb4805e_z.jpg --output {input_image_filename}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here is how our chosen image looks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x68b982f0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.pyplot import imshow\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "image_to_show = Image.open(input_image_filename)\n",
    "imshow(np.asarray(image_to_show))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Measure Inference Latency\n",
    "\n",
    "We will be measuring the inference latency of the SageMaker Neo-compiled model and comparing it to that of the original TensorFlow Lite model. The measurement process will be as follows:\n",
    "\n",
    "1. Load the image used for inference into a usable input format\n",
    "2. Perform 25 inferences in a tight loop in order to warm up the Raspberry Pi\n",
    "3. Perform 50 inferences in a tight loop, recording the time required for each\n",
    "4. Repeat for the next framework\n",
    "\n",
    "We first import all necessary packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import tensorflow as tf\n",
    "import dlr\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take a moment to note the versions of DLR (which executes the Neo-compiled model) and TensorFlow being used.\n",
    "\n",
    "> Models compiled using SageMaker Neo include a `libdlr.so` responsible for executing the model, so performance can vary even with the same DLR version, depending on the latest SageMaker Neo updates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow version: 1.14.0\n",
      "DLR version: 1.3.0\n"
     ]
    }
   ],
   "source": [
    "print('TensorFlow version:', tf.__version__)\n",
    "print('DLR version:', dlr.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now read in the image, as it will be used in both benchmarks, and set the values of constants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_WARMUP = 25\n",
    "NUM_ACTUAL = 50\n",
    "\n",
    "image = Image.open(input_image_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model expects a input image of size 300x300, so we need to resize our input image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "resized_image = image.resize((300, 300))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the image read into memory and resized, it is now time to benchmark. \n",
    "\n",
    "#### Benchmark TensorFlow Lite\n",
    "\n",
    "We first measure latency when executing using TensorFlow Lite to get a baseline level of performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "95th percentile latency: 413.3474111557007 ms\n",
      "99th percentile latency: 422.1384835243225 ms\n"
     ]
    }
   ],
   "source": [
    "def benchmark_tensorflow(image):\n",
    "    \"\"\"Measure the p99 and p95 latencies of the TensorFlow Lite model.\"\"\"\n",
    "    # Load in the model\n",
    "    interpreter = tf.lite.Interpreter(model_path='./detect.tflite')\n",
    "    # Required setup\n",
    "    interpreter.allocate_tensors()\n",
    "\n",
    "    # Get a handle so we know where to put the image\n",
    "    input_details = interpreter.get_input_details()\n",
    "    x = interpreter.tensor(input_details[0]['index'])\n",
    "    \n",
    "    # Our model is quantized, so we must convert the image to uint8\n",
    "    x = np.array(image).astype('uint8')\n",
    "        \n",
    "    # TensorFlow Lite expects for there to be a 4th dimension for\n",
    "    # batch size\n",
    "    x = np.expand_dims(x, axis=0)\n",
    "\n",
    "    \n",
    "    # Warmup runs\n",
    "    for i in range(NUM_WARMUP):\n",
    "        interpreter.invoke()\n",
    "\n",
    "    latencies = []\n",
    "\n",
    "    for _ in range(NUM_ACTUAL):\n",
    "        start_time = time.time()\n",
    "        interpreter.invoke()\n",
    "        elapsed_seconds = time.time() - start_time\n",
    "        elapsed_ms = elapsed_seconds * 1000\n",
    "        latencies.append(elapsed_ms)\n",
    "\n",
    "    p99_latency = np.percentile(latencies, 99)\n",
    "    p95_latency = np.percentile(latencies, 95)\n",
    "    print(f'95th percentile latency: {p95_latency} ms')\n",
    "    print(f'99th percentile latency: {p99_latency} ms')\n",
    "    \n",
    "    return (p99_latency, p95_latency)\n",
    "tf_p99_latency, tf_p95_latency = benchmark_tensorflow(resized_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Benchmark DLR/Neo\n",
    "\n",
    "Before we can run the model we compiled with neo, we first need to extract it from the tar.gz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir ./dlr_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "compiled.meta\n",
      "libdlr.so\n",
      "dlr.h\n",
      "compiled.params\n",
      "compiled_model.json\n",
      "compiled.so\n"
     ]
    }
   ],
   "source": [
    "!tar -xzvf ./compiled-detect.tar.gz --directory ./dlr_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we measure the performance of our Neo-Compiled model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-10-14 11:43:12,383 INFO Found libdlr.so in model artifact. Using dlr from ./dlr_model/libdlr.so\n",
      "2020-10-14 11:43:12,383 INFO Found libdlr.so in model artifact. Using dlr from ./dlr_model/libdlr.so\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "95th percentile latency: 252.2238850593567 ms\n",
      "99th percentile latency: 252.3707127571106 ms\n"
     ]
    }
   ],
   "source": [
    "def benchmark_dlr(image):\n",
    "    \"\"\"Measure the p99 and p95 latencies of the Neo/DLR model.\"\"\"\n",
    "    # Load in the model\n",
    "    model = dlr.DLRModel('./dlr_model', 'cpu', 0)\n",
    "    x = np.array(image).astype('uint8')\n",
    "\n",
    "    # Warmup runs\n",
    "    for i in range(NUM_WARMUP):\n",
    "        model.run(x)\n",
    "\n",
    "    latencies = []\n",
    "\n",
    "    # Actual measurements\n",
    "    for i in range(NUM_ACTUAL):\n",
    "        start_time = time.time()\n",
    "        model.run(x)\n",
    "        elapsed_seconds = time.time() - start_time\n",
    "        elapsed_ms = elapsed_seconds * 1000\n",
    "        latencies.append(elapsed_ms)\n",
    "\n",
    "    p99_latency = np.percentile(latencies, 99)\n",
    "    p95_latency = np.percentile(latencies, 95)\n",
    "    print(f'95th percentile latency: {p95_latency} ms')\n",
    "    print(f'99th percentile latency: {p99_latency} ms')\n",
    "    \n",
    "    return (p99_latency, p95_latency)\n",
    "neo_p99_latency, neo_p95_latency = benchmark_dlr(resized_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Speedup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We see a 1.64x speedup at the 95th percentile after compiling with SageMaker Neo.\n"
     ]
    }
   ],
   "source": [
    "print('We see a {0:1.2f}x speedup at the 95th percentile after compiling with SageMaker Neo.'\\\n",
    "      .format(tf_p95_latency / neo_p95_latency))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note: While Neo/DLR uses multithreading by default, TensorFlow Lite typically does not use multiple threads unless explicitly specified. The ability to set `num_threads` through the TensorFlow Lite Python API requires TensorFlow >= 2.3.0, so we are not able to use multithreaded TensorFlow Lite here as we only have TensorFlow Lite 1.14.0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Results\n",
    "\n",
    "With our benchmarking done, it is now time to plot our results. \n",
    "\n",
    "Pull together our results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO(dvisnty): Show speedup instead of raw latency?\n",
    "labels = ['TensorFlow Lite', 'Neo/DLR']\n",
    "p95s = np.array([tf_p95_latency, neo_p95_latency]).astype('int')\n",
    "p99s = np.array([tf_p99_latency, neo_p99_latency]).astype('int')\n",
    "x = np.arange(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "width = 0.35  # the width of the bars\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, p95s, width, label='95th Percentile Latency')\n",
    "rects2 = ax.bar(x + width/2, p99s, width, label='99th Percentile Latency')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Latency (ms)')\n",
    "ax.set_title('p95 and p99 Latency by Framework')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "\n",
    "\n",
    "def autolabel(rects):\n",
    "    \"\"\"Attach a text label above each bar in *rects*, displaying its height.\"\"\"\n",
    "    for rect in rects:\n",
    "        height = rect.get_height()\n",
    "        ax.annotate(\n",
    "            '{}'.format(height),\n",
    "            xy=(rect.get_x() + rect.get_width() / 2, height),\n",
    "            xytext=(0, 3),  # 3 points vertical offset\n",
    "            textcoords=\"offset points\",\n",
    "            ha='center',\n",
    "            va='bottom',\n",
    "        )\n",
    "\n",
    "\n",
    "autolabel(rects1)\n",
    "autolabel(rects2)\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.show()\n",
    "plt.savefig('latency_results.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "This tutorial showed how to compile an object detection model built in TensorFlow Lite for inference on a Raspberry Pi 3B using SageMaker Neo. It also walked through how to measure the performance benefits of compiling with SageMaker Neo, showing a speedup of approximately 60%.\n",
    "\n",
    "This notebook is only a brief introduction to the capabilities of SageMaker Neo, and it did not touch on other benefits such as memory usage reduction, portability, or the optimized use of accelerators. To learn more about these features, please visit the [SageMaker Neo documentaiton](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
